home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / front.lha / front / m2c / TokenTab.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  8KB  |  356 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Strings
  4. #include "Strings.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Idents
  8. #include "Idents.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Errors
  12. #include "Errors.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Positions
  16. #include "Positions.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_TokenTab
  20. #include "TokenTab.h"
  21. #endif
  22.  
  23. SHORTCARD TokenTab_MAXTerm;
  24. SHORTCARD TokenTab_MAXNonTerm;
  25.  
  26. #define eNoIntCode    25
  27. #define eTokenOverflow    26
  28. #define MaxTokens    TokenTab_cMAXNonTerm
  29. #define NoValue    MaxTokens
  30. #define DefValue    (MaxTokens + 1)
  31. typedef LONGCARD Symbols;
  32. static struct S_1 {
  33.     TokenTab_Vocabulary A[MaxTokens + 1];
  34. } ExToInt;
  35. static struct S_2 {
  36.     TokenTab_PosType A[MaxTokens + 1];
  37. } ExToPos;
  38. static struct S_3 {
  39.     BOOLEAN A[MaxTokens + 1];
  40. } ExPosSet;
  41. static struct S_4 {
  42.     Symbols A[TokenTab_cMAXNonTerm + 2 + 1];
  43. } IntToEx;
  44. static struct S_5 {
  45.     TokenTab_Prio A[TokenTab_cMAXNonTerm + 2 + 1];
  46. } PrioField;
  47. static LONGCARD DefaultVoc;
  48. static CARDINAL i;
  49. static BOOLEAN GetNextNonTerminalAllowed;
  50. static LONGCARD Actualnt;
  51. static TokenTab_Terminal ter;
  52. static TokenTab_TokenError err;
  53. static Strings_tString s;
  54. static TokenTab_PosType pos;
  55. static void NextDefault ARGS(());
  56. static void ERROR ARGS((CHAR a[], LONGCARD ));
  57.  
  58.  
  59. void TokenTab_MakeTerm
  60. # ifdef __STDC__
  61. (Idents_tIdent sym, TokenTab_Terminal *ter, TokenTab_TokenError *Error, TokenTab_PosType pos)
  62. # else
  63. (sym, ter, Error, pos)
  64. Idents_tIdent sym;
  65. TokenTab_Terminal *ter;
  66. TokenTab_TokenError *Error;
  67. TokenTab_PosType pos;
  68. # endif
  69. {
  70.   if (sym > TokenTab_cMAXNonTerm) {
  71.     *Error = TokenTab_OutOfRange;
  72.   } else if (ExToInt.A[sym] != NoValue) {
  73.     *Error = TokenTab_SymbolExists;
  74.     *ter = ExToInt.A[sym];
  75.   } else if (IntToEx.A[*ter] != NoValue) {
  76.     *Error = TokenTab_CodeExists;
  77.   } else {
  78.     ExToInt.A[sym] = *ter;
  79.     IntToEx.A[*ter] = sym;
  80.     *Error = TokenTab_NoError;
  81.     ExToPos.A[sym] = pos;
  82.     if (*ter > TokenTab_MAXTerm) {
  83.       TokenTab_MAXTerm = *ter;
  84.     }
  85.   }
  86. }
  87.  
  88. void TokenTab_MakeDefTerm
  89. # ifdef __STDC__
  90. (Idents_tIdent *sym, TokenTab_TokenError *Error, TokenTab_PosType pos)
  91. # else
  92. (sym, Error, pos)
  93. Idents_tIdent *sym;
  94. TokenTab_TokenError *Error;
  95. TokenTab_PosType pos;
  96. # endif
  97. {
  98.   if (ExToInt.A[*sym] != NoValue) {
  99.     *Error = TokenTab_SymbolExists;
  100.   } else {
  101.     ExToInt.A[*sym] = DefValue;
  102.     *Error = TokenTab_NoError;
  103.     ExToPos.A[*sym] = pos;
  104.   }
  105. }
  106.  
  107. void TokenTab_CompleteDefTerm
  108. # ifdef __STDC__
  109. (Idents_tIdent sym, TokenTab_TokenError *Error)
  110. # else
  111. (sym, Error)
  112. Idents_tIdent sym;
  113. TokenTab_TokenError *Error;
  114. # endif
  115. {
  116.   if (ExToInt.A[sym] == NoValue) {
  117.     *Error = TokenTab_NotExists;
  118.   } else if (ExToInt.A[sym] != DefValue) {
  119.     if (TokenTab_GetTokenType(ExToInt.A[sym]) == TokenTab_NonTerm) {
  120.       *Error = TokenTab_NotTerm;
  121.     } else {
  122.       *Error = TokenTab_CodeExists;
  123.     }
  124.   } else {
  125.     NextDefault();
  126.     if (DefaultVoc <= TokenTab_cMAXTerm) {
  127.       ExToInt.A[sym] = DefaultVoc;
  128.       IntToEx.A[DefaultVoc] = sym;
  129.       if (DefaultVoc > TokenTab_MAXTerm) {
  130.         TokenTab_MAXTerm = DefaultVoc;
  131.       }
  132.       *Error = TokenTab_NoError;
  133.     } else {
  134.       Errors_ErrorMessageI((LONGCARD)eTokenOverflow, (LONGCARD)Errors_eRestriction, Positions_NoPosition, (LONGCARD)Errors_eIdent, ADR(sym));
  135.     }
  136.   }
  137. }
  138.  
  139. TokenTab_Vocabulary TokenTab_MakeVoc
  140. # ifdef __STDC__
  141. (Idents_tIdent sym, TokenTab_PosType symPos)
  142. # else
  143. (sym, symPos)
  144. Idents_tIdent sym;
  145. TokenTab_PosType symPos;
  146. # endif
  147. {
  148.   if (ExToInt.A[sym] == DefValue) {
  149.     Errors_ErrorMessageI((LONGCARD)eNoIntCode, (LONGCARD)Errors_eFatal, symPos, (LONGCARD)Errors_eIdent, ADR(sym));
  150.   } else if (ExToInt.A[sym] != NoValue) {
  151.     if (ExToPos.A[sym].Line > symPos.Line || ExToPos.A[sym].Line == symPos.Line && ExToPos.A[sym].Column > symPos.Column) {
  152.       if (symPos.Line != 0 && symPos.Column != 0) {
  153.         ExToPos.A[sym] = symPos;
  154.       }
  155.     }
  156.     return ExToInt.A[sym];
  157.   } else {
  158.     INC(TokenTab_MAXNonTerm);
  159.     if (TokenTab_MAXNonTerm >= MaxTokens) {
  160.       Errors_ErrorMessageI((LONGCARD)eTokenOverflow, (LONGCARD)Errors_eRestriction, symPos, (LONGCARD)Errors_eIdent, ADR(sym));
  161.     } else {
  162.       ExToPos.A[sym] = symPos;
  163.       ExToInt.A[sym] = TokenTab_MAXNonTerm;
  164.       IntToEx.A[TokenTab_MAXNonTerm] = sym;
  165.       return TokenTab_MAXNonTerm;
  166.     }
  167.   }
  168. }
  169.  
  170. void TokenTab_SetNontermPos
  171. # ifdef __STDC__
  172. (Idents_tIdent sym, TokenTab_PosType pos)
  173. # else
  174. (sym, pos)
  175. Idents_tIdent sym;
  176. TokenTab_PosType pos;
  177. # endif
  178. {
  179.   if (!ExPosSet.A[sym]) {
  180.     ExToPos.A[sym] = pos;
  181.     ExPosSet.A[sym] = TRUE;
  182.   }
  183. }
  184.  
  185. TokenTab_TokenType TokenTab_GetTokenType
  186. # ifdef __STDC__
  187. (TokenTab_Vocabulary voc)
  188. # else
  189. (voc)
  190. TokenTab_Vocabulary voc;
  191. # endif
  192. {
  193.   if (IntToEx.A[voc] == NoValue || voc >= MaxTokens) {
  194.     return TokenTab_None;
  195.   } else if (voc <= TokenTab_cMAXTerm) {
  196.     return TokenTab_Term;
  197.   } else {
  198.     return TokenTab_NonTerm;
  199.   }
  200. }
  201.  
  202. TokenTab_Vocabulary TokenTab_SymbolToToken
  203. # ifdef __STDC__
  204. (Idents_tIdent sym, TokenTab_TokenError *Error)
  205. # else
  206. (sym, Error)
  207. Idents_tIdent sym;
  208. TokenTab_TokenError *Error;
  209. # endif
  210. {
  211.   if (ExToInt.A[sym] == NoValue) {
  212.     *Error = TokenTab_NotExists;
  213.   } else if (ExToInt.A[sym] == DefValue) {
  214.     *Error = TokenTab_NoIntCode;
  215.   } else {
  216.     *Error = TokenTab_NoError;
  217.   }
  218.   return ExToInt.A[sym];
  219. }
  220.  
  221. Idents_tIdent TokenTab_TokenToSymbol
  222. # ifdef __STDC__
  223. (TokenTab_Vocabulary voc, TokenTab_TokenError *Error)
  224. # else
  225. (voc, Error)
  226. TokenTab_Vocabulary voc;
  227. TokenTab_TokenError *Error;
  228. # endif
  229. {
  230.   if (IntToEx.A[voc] == NoValue) {
  231.     *Error = TokenTab_NotExists;
  232.   } else {
  233.     *Error = TokenTab_NoError;
  234.   }
  235.   return IntToEx.A[voc];
  236. }
  237.  
  238. void TokenTab_GetTokenPos
  239. # ifdef __STDC__
  240. (TokenTab_Vocabulary voc, TokenTab_PosType *pos)
  241. # else
  242. (voc, pos)
  243. TokenTab_Vocabulary voc;
  244. TokenTab_PosType *pos;
  245. # endif
  246. {
  247.   Idents_tIdent sym;
  248.  
  249.   sym = IntToEx.A[voc];
  250.   if (sym == NoValue) {
  251.     pos->Line = 0;
  252.     pos->Column = 0;
  253.   } else {
  254.     *pos = ExToPos.A[sym];
  255.   }
  256. }
  257.  
  258. void TokenTab_PutPrio
  259. # ifdef __STDC__
  260. (TokenTab_Vocabulary voc, TokenTab_Prio p)
  261. # else
  262. (voc, p)
  263. TokenTab_Vocabulary voc;
  264. TokenTab_Prio p;
  265. # endif
  266. {
  267.   PrioField.A[voc] = p;
  268. }
  269.  
  270. TokenTab_Prio TokenTab_GetPrio
  271. # ifdef __STDC__
  272. (TokenTab_Vocabulary voc)
  273. # else
  274. (voc)
  275. TokenTab_Vocabulary voc;
  276. # endif
  277. {
  278.   return PrioField.A[voc];
  279. }
  280.  
  281. static void NextDefault
  282. # ifdef __STDC__
  283. ()
  284. # else
  285. ()
  286. # endif
  287. {
  288.   while (IntToEx.A[DefaultVoc] != NoValue && DefaultVoc < TokenTab_cMAXTerm + 1) {
  289.     INC(DefaultVoc);
  290.   }
  291. }
  292.  
  293. void TokenTab_InitTokenTable
  294. # ifdef __STDC__
  295. ()
  296. # else
  297. ()
  298. # endif
  299. {
  300.   GetNextNonTerminalAllowed = FALSE;
  301.   for (i = 0; i <= MaxTokens; i += 1) {
  302.     IntToEx.A[i] = NoValue;
  303.     ExToInt.A[i] = NoValue;
  304.     ExPosSet.A[i] = FALSE;
  305.     PrioField.A[i] = 0;
  306.   }
  307.   DefaultVoc = 1;
  308.   TokenTab_MAXNonTerm = TokenTab_cMAXTerm;
  309.   Strings_ArrayToString((STRING)"_EndOfFile", 10L, &s);
  310.   ter = TokenTab_EndOfToken;
  311.   pos.Line = 0;
  312.   pos.Column = 0;
  313.   TokenTab_MakeTerm(Idents_MakeIdent(&s), &ter, &err, pos);
  314.   if (err != TokenTab_NoError) {
  315.     ERROR((STRING)"TokenTab.InitTokenTable", 23L);
  316.   }
  317.   TokenTab_MAXTerm = 0;
  318. }
  319.  
  320. static void ERROR
  321. # ifdef __STDC__
  322. (CHAR a[], LONGCARD O_1)
  323. # else
  324. (a, O_1)
  325. CHAR a[];
  326. LONGCARD O_1;
  327. # endif
  328. {
  329.   Strings_tString s;
  330.   OPEN_ARRAY_LOCALS
  331.  
  332.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  333.   COPY_OPEN_ARRAY(a, O_1, CHAR)
  334.   Strings_ArrayToString(a, O_1, &s);
  335.   Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Positions_NoPosition, (LONGCARD)Errors_eString, ADR(s));
  336.   FREE_OPEN_ARRAYS
  337. }
  338.  
  339. void BEGIN_TokenTab()
  340. {
  341.   static BOOLEAN has_been_called = FALSE;
  342.  
  343.   if (!has_been_called) {
  344.     has_been_called = TRUE;
  345.  
  346.     BEGIN_Strings();
  347.     BEGIN_Idents();
  348.     BEGIN_Positions();
  349.     BEGIN_Strings();
  350.     BEGIN_Idents();
  351.     BEGIN_Errors();
  352.     BEGIN_Positions();
  353.  
  354.   }
  355. }
  356.